using Microsoft.AspNetCore.Http;
using System.Security.Claims;
using UniversalAdmin.Application.DTOs;
using UniversalAdmin.Application.Services;

namespace UniversalAdmin.Api.Middleware;

public class PermissionMiddleware
{
    private readonly RequestDelegate _next;

    public PermissionMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // 跳过不需要权限检查的路径
        if (ShouldSkipPermissionCheck(context.Request.Path))
        {
            // 对于跳过的路径，仍然需要检查认证（如果控制器有[Authorize]属性）
            await _next(context);
            return;
        }

        // 检查用户是否已认证
        if (!context.User.Identity?.IsAuthenticated ?? true)
        {
            context.Response.StatusCode = 401;
            await context.Response.WriteAsJsonAsync(new { message = "未认证" });
            return;
        }

        // 检查用户是否有权限访问当前路径
        var hasPermission = await CheckUserPermissionAsync(context);
        if (!hasPermission)
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsJsonAsync(new { message = "权限不足" });
            return;
        }

        await _next(context);
    }

    private bool ShouldSkipPermissionCheck(PathString path)
    {
        // 跳过不需要权限检查的路径
        var skipPaths = new[]
        {
            "/swagger",
            "/health",
            "/favicon.ico",
            "/api/v1/auth/login",
            "/api/v1/auth/register",
            "/api/v1/init",  // 跳过初始化API，允许匿名访问
            "/api/v1/Init",  // 跳过初始化API（大写），允许匿名访问
            "/api/v1/menu",  // 跳过菜单API，避免循环依赖
            "/api/v1/Menu",  // 跳过菜单API（大写），避免循环依赖
            "/api/v1/permission",  // 跳过权限API，避免循环依赖
            "/api/v1/Permission",  // 跳过权限API（大写），避免循环依赖
            "/api/v1/role",  // 跳过角色API，避免循环依赖
            "/api/v1/Role",  // 跳过角色API（大写），避免循环依赖
            "/api/v1/user",  // 跳过用户API，避免循环依赖
            "/api/v1/User",  // 跳过用户API（大写），避免循环依赖
            "/api/v1/personal",  // 跳过个人中心API，避免循环依赖
            "/api/v1/Personal",  // 跳过个人中心API（大写），避免循环依赖
            "/api/v1/operationlog",  // 跳过日志管理API，避免循环依赖
            "/api/v1/OperationLog"  // 跳过日志管理API（大写），避免循环依赖
        };

        return skipPaths.Any(skipPath => path.StartsWithSegments(skipPath));
    }

    private async Task<bool> CheckUserPermissionAsync(HttpContext context)
    {
        try
        {
            // 从服务提供器获取作用域服务
            var menuService = context.RequestServices.GetRequiredService<IMenuService>();
            var userService = context.RequestServices.GetRequiredService<IUserService>();

            // 获取当前用户ID
            var userIdClaim = context.User.FindFirst(ClaimTypes.NameIdentifier);
            if (userIdClaim == null || !Guid.TryParse(userIdClaim.Value, out var userId))
                return false;

            // 获取用户信息
            var user = await userService.GetUserByIdAsync(userId);
            if (user == null) return false;

            // 超级管理员拥有所有权限
            if (user.Roles.Any(r => r.Name == "SuperAdmin"))
                return true;

            // 获取当前请求的路径
            var requestPath = context.Request.Path.Value?.ToLower();
            if (string.IsNullOrEmpty(requestPath)) return false;

            // 获取所有菜单
            var allMenus = await menuService.GetAllMenusAsync();

            // 查找匹配的菜单
            var matchingMenu = allMenus.FirstOrDefault(m =>
                requestPath.Contains(m.Path.ToLower()) ||
                requestPath.EndsWith(m.Path.ToLower()));

            if (matchingMenu == null) return true; // 如果没有匹配的菜单，允许访问

            // 检查用户角色是否有权限访问该菜单
            foreach (var role in user.Roles)
            {
                var roleMenus = await menuService.GetMenusByRoleAsync(role.Id);
                if (roleMenus.Any(m => m.Id == matchingMenu.Id))
                    return true;
            }

            return false;
        }
        catch
        {
            // 如果权限检查过程中出现异常，拒绝访问
            return false;
        }
    }
}